{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "OHoSU6uI-xIt"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nhttps://zhuanlan.zhihu.com/p/656515516\\n强化学习的两个主要组成部分就是：0、智能体或者大脑；1、环境。环境是给定的，也就是一般由openai提供的gym库，或者gymnasium这个库。这两个库提供了很多不同的强化学习环境，可以拿来调用的，上面的悬崖环境就在gymnasium库内的，gym库已经不再update了。\\n智能体或者大脑：智能体根据策略或者大脑，根据环境给出的奖励reward，以及分析环境提供的状态state信息，进而给出下一步的动作action；智能体还需要能够拿到状态信息，像robot就有许许多多的传感器，来感知环境的状态信息的。\\n环境：环境一般是连续的不离散的，环境需要根据智能体给出的动作action做出相应的改变，还需要给出相应的奖励reward，以及状态信息state，状态信息通常是需要智能体主动获取的，当然比较简单的环境可能就直接给出了状态信息，不需要智能体主动获取。\\n一般环境是gymnasium库提供的内容，环境会负责step(action)前进一步的，每次根据动作前进一步或者执行一步，会返回next_state, reward, done, _，也就分别是 下一个状体、奖励、是否结束的。或者重置环境reset()。\\n智能体是需要program的，也就是需要人工手动program，给出策略或者深度神经网络模拟大脑，每次从环境拿到状态信息state，以及reward奖励的，智能体根据奖励以及分析拿到的状态信息，做出决策的，也就是给出动作action。\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "import gymnasium as gym\n",
    "import numpy as np\n",
    "import collections\n",
    "from tqdm import tqdm\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import rl_utils\n",
    "import cv2\n",
    "import imageio\n",
    "'''\n",
    "https://zhuanlan.zhihu.com/p/656515516\n",
    "强化学习的两个主要组成部分就是：0、智能体或者大脑；1、环境。环境是给定的，也就是一般由openai提供的gym库，或者gymnasium这个库。这两个库提供了很多不同的强化学习环境，可以拿来调用的，上面的悬崖环境就在gymnasium库内的，gym库已经不再update了。\n",
    "智能体或者大脑：智能体根据策略或者大脑，根据环境给出的奖励reward，以及分析环境提供的状态state信息，进而给出下一步的动作action；智能体还需要能够拿到状态信息，像robot就有许许多多的传感器，来感知环境的状态信息的。\n",
    "环境：环境一般是连续的不离散的，环境需要根据智能体给出的动作action做出相应的改变，还需要给出相应的奖励reward，以及状态信息state，状态信息通常是需要智能体主动获取的，当然比较简单的环境可能就直接给出了状态信息，不需要智能体主动获取。\n",
    "一般环境是gymnasium库提供的内容，环境会负责step(action)前进一步的，每次根据动作前进一步或者执行一步，会返回next_state, reward, done, _，也就分别是 下一个状体、奖励、是否结束的。或者重置环境reset()。\n",
    "智能体是需要program的，也就是需要人工手动program，给出策略或者深度神经网络模拟大脑，每次从环境拿到状态信息state，以及reward奖励的，智能体根据奖励以及分析拿到的状态信息，做出决策的，也就是给出动作action。\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "TsptTKz6-xIv"
   },
   "outputs": [],
   "source": [
    "## 保存历史数据，采样历史数据，拿到历史数据\n",
    "class ReplayBuffer:\n",
    "    ''' 经验回放池 '''\n",
    "    def __init__(self, capacity): ## 容量的大小\n",
    "        self.buffer = collections.deque(maxlen=capacity)  # 队列,先进先出\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):  # 将数据加入buffer\n",
    "        self.buffer.append((state, action, reward, next_state, done))  ## 加入到队列内部\n",
    "\n",
    "    def sample(self, batch_size):  # 从buffer中采样数据,数量为batch_size\n",
    "        transitions = random.sample(self.buffer, batch_size)  ## 随机采样的呢，拿到采样的历史数据\n",
    "        state, action, reward, next_state, done = zip(*transitions)  ## 使用zip来转置，也就是不同的自变量在不同的行\n",
    "        return np.array(state), action, reward, np.array(next_state), done  ## 状态、动作、奖励、下一个状态，是否结束的\n",
    "\n",
    "    def size(self):  # 目前buffer中数据的数量\n",
    "        return len(self.buffer)  ##  返回历史数据的总长度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "_qO6koMR-xIw"
   },
   "outputs": [],
   "source": [
    "## 构造智能体agent的大脑，也就是输入状态，返回该状态下，每个动作的动作价值\n",
    "## 输入是状态的，也就是 (车子center-point的坐标，车子的速度，杆的竖直角度，杆的角速度)\n",
    "## 返回值应该是2 dim，\n",
    "class Qnet(torch.nn.Module):\n",
    "    ''' 只有一层隐藏层的Q网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(Qnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)  ## full connect层1\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim) ## full connect层2\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))  # 隐藏层使用ReLU激活函数\n",
    "        return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "wxZItCX4-xIw"
   },
   "outputs": [],
   "source": [
    "##  构造智能体的\n",
    "class DQN:\n",
    "    ''' DQN算法 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,\n",
    "                 epsilon, target_update, device):\n",
    "        self.action_dim = action_dim  ##  动作的dim\n",
    "        ## 实例化智能体的大脑\n",
    "        self.q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)  # Q网络\n",
    "        # 目标网络\n",
    "        self.target_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "        # 使用Adam优化器\n",
    "        self.optimizer = torch.optim.Adam(self.q_net.parameters(), lr=learning_rate)\n",
    "        self.gamma = gamma  # 折扣因子\n",
    "        self.epsilon = epsilon  # epsilon-贪婪策略\n",
    "        self.target_update = target_update  # 目标网络更新频率\n",
    "        self.count = 0  # 计数器,记录更新次数\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):  # epsilon-贪婪策略采取动作\n",
    "        # if np.random.random() < self.epsilon * np.exp(-self.count/100):\n",
    "        if np.random.random() < self.epsilon:\n",
    "            action = np.random.randint(self.action_dim) ## 随机选择一个动作\n",
    "        else:\n",
    "            state = torch.tensor([state], dtype=torch.float).to(self.device) ## 状态\n",
    "            action = self.q_net(state).argmax().item()  ## 智能体的大脑，根据状态拿到动作价值，q_net返回值是每个动作的动作价值，然后拿到动作的\n",
    "        return action\n",
    "\n",
    "    ## 使用历史数据来训练智能体的大脑，两个大脑的，一个实时update做label，另一个延迟update做predict\n",
    "    '''\n",
    "    损失函数需要label和predict，但是强化学习是没有label的，所以需要人工构造label才行，DQN使用的构造方式是使用update步长不相同的两个Qnet，\n",
    "    update数量较多的Qnet来做label，数量较少的Qnet来做predict。所以label就是使用的newest update的Qnet。相当是两个人，一个学的时间长些，\n",
    "    一个学的时间短些，所以这个学习时间更长的人，可以当老师了，学习时间短的人，就只能当学生了。老师可以教导学生的。所以两个大脑模型Qnet，\n",
    "    一个做老师，一个是学生，也就是一个label另一个则是predict。这样就构造出了相应的label。\n",
    "    target_q_net使用下一个状态，然后Q-learning来predict当前(状态，动作)的动作价值，predict\n",
    "    q_net使用当前状态和动作，直接算出当前(状态，动作)的动作价值，label\n",
    "    '''\n",
    "    def update(self, transition_dict):\n",
    "        ## 初始化 状态、动作、奖励、下一个状态、是否结束的\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "\n",
    "        ## target, 因该网络实时update，所以可以看作是真实值，也就是监督学习内的label，而目标网络延迟很多，目标网络的输出可以看作predict\n",
    "        ## “真实”label，q_net输入当前的状态，返回值是当前状态下每个动作的动作价值，所以gather以后拿到的是：当前(状态和动作)对应的动作价值\n",
    "        q_values = self.q_net(states).gather(1, actions)  # Q值\n",
    "        # 下个状态的最大Q值，延迟网络的输出\n",
    "        ## 可以看作是predict，输入是下一个状态，返回值是下一个状态所有动作的动作价值内的最大值\n",
    "        ## 用来算当前(状态和动作)下的动作价值\n",
    "        max_next_q_values = self.target_q_net(next_states).max(1)[0].view(-1, 1)\n",
    "        ## Q-learning algorithm，算出的是当前(状态和动作)的动作价值\n",
    "        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)  # TD误差目标\n",
    "        ## q_net的truth label 和 target_q_net的predict，算损失用来反向传播\n",
    "        ## 也就是两个网络算出来的（状态和动作）对应的动作价值，用MSE来算损失函数的呢\n",
    "        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))  # 均方误差损失函数\n",
    "        self.optimizer.zero_grad()  # PyTorch中默认梯度会累积,这里需要显式将梯度置为0\n",
    "        dqn_loss.backward()   ##  反向传播求出梯度\n",
    "        self.optimizer.step() ##  使用累加的梯度来update参数\n",
    "\n",
    "        if self.count % self.target_update == 0:    ##  达到了给定的步长，复制最newest的参数给target_q_net网络，q_net是label，target_q_net是predict\n",
    "            self.target_q_net.load_state_dict(self.q_net.state_dict())  # 更新目标网络\n",
    "        self.count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 97226,
     "status": "ok",
     "timestamp": 1649955480772,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "acJ1letz-xIx",
    "outputId": "26487c0d-c504-44d6-eb15-5fb137b9488f"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|          | 0/50 [00:00<?, ?it/s]"
     ]
    }
   ],
   "source": [
    "lr = 2e-3\n",
    "num_episodes = 500\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "epsilon = 0.01\n",
    "target_update = 10\n",
    "buffer_size = 10000\n",
    "minimal_size = 500\n",
    "batch_size = 64\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "_ = env.reset(seed=0)\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "gym.utils.seeding.np_random(0)\n",
    "torch.manual_seed(0)\n",
    "replay_buffer = ReplayBuffer(buffer_size)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.n\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,\n",
    "            target_update, device)\n",
    "\n",
    "return_list = []\n",
    "allimage = []\n",
    "for i in range(10):\n",
    "    ## 训练的次数是\n",
    "    with tqdm(total=int(num_episodes / 10), desc='Iteration %d' % i) as pbar:\n",
    "        for i_episode in range(int(num_episodes / 10)):\n",
    "            episode_return = 0   ## 累积的奖励\n",
    "            state = env.reset()  ## 环境随机重置的\n",
    "            \n",
    "            if len(state)!=2*2:\n",
    "                state = state[0]\n",
    "            done = False\n",
    "            # https://huggingface.co/learn/deep-rl-course/unit4/hands-on#create-a-virtual-display\n",
    "            while not done:\n",
    "                if (i_episode + 1) % 10 == 0 and i in [9]:\n",
    "                    img = env.render()\n",
    "                    allimage.append(img)\n",
    "                # cv2.imshow(\"CartPole-v1\", img)\n",
    "                # cv2.waitKey(-1)\n",
    "                \n",
    "                action = agent.take_action(state) ## 拿到动作价值最大的动作，取值可选值是：0 或者 1\n",
    "                ## 环境根据动作，前进一步的，拿到下一个状态，奖励，是否终止，是否步长太长，info\n",
    "                next_state, reward, terminated, truncated, info = env.step(action)  \n",
    "                done = terminated | truncated  ## 终止或者步长太长，都会导致已经结束\n",
    "                ## 将状态、动作、奖励、下一个状态、是否结束，加入到缓冲池，也就是历史内，用来训练大脑网络的\n",
    "                replay_buffer.add(state, action, reward, next_state, done)\n",
    "                state = next_state   ## 下一个状态赋值到当前状态\n",
    "                episode_return += reward  ##累加奖励的\n",
    "                # 当buffer数据的数量超过一定值后,才进行Q网络训练\n",
    "                if replay_buffer.size() > minimal_size:         ## 不停的和环境交互，直到缓冲池内的历史数据大于一定的数量，再开始训练网络的\n",
    "                    ## 从缓冲池采样历史数据，用来训练大脑网络的\n",
    "                    b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(batch_size)\n",
    "                    transition_dict = {      ##  拿到的历史数据\n",
    "                        'states': b_s,\n",
    "                        'actions': b_a,\n",
    "                        'next_states': b_ns,\n",
    "                        'rewards': b_r,\n",
    "                        'dones': b_d\n",
    "                    }\n",
    "                    agent.update(transition_dict)  ## 训练大脑网络 q_net\n",
    "            return_list.append(episode_return)\n",
    "            if (i_episode + 1) % 10 == 0:\n",
    "                pbar.set_postfix({\n",
    "                    'episode':\n",
    "                    '%d' % (num_episodes / 10 * i + i_episode + 1),\n",
    "                    'return':\n",
    "                    '%.3f' % np.mean(return_list[-10:])\n",
    "                })\n",
    "            pbar.update(1)\n",
    "\n",
    "# Iteration 0: 100%|██████████| 50/50 [00:00<00:00, 764.86it/s, episode=50,\n",
    "# return=9.300]\n",
    "# Iteration 1: 100%|██████████| 50/50 [00:04<00:00, 10.66it/s, episode=100,\n",
    "# return=12.300]\n",
    "# Iteration 2: 100%|██████████| 50/50 [00:24<00:00,  2.05it/s, episode=150,\n",
    "# return=123.000]\n",
    "# Iteration 3: 100%|██████████| 50/50 [01:25<00:00,  1.71s/it, episode=200,\n",
    "# return=153.600]\n",
    "# Iteration 4: 100%|██████████| 50/50 [01:30<00:00,  1.80s/it, episode=250,\n",
    "# return=180.500]\n",
    "# Iteration 5: 100%|██████████| 50/50 [01:24<00:00,  1.68s/it, episode=300,\n",
    "# return=185.000]\n",
    "# Iteration 6: 100%|██████████| 50/50 [01:32<00:00,  1.85s/it, episode=350,\n",
    "# return=193.900]\n",
    "# Iteration 7: 100%|██████████| 50/50 [01:31<00:00,  1.84s/it, episode=400,\n",
    "# return=196.600]\n",
    "# Iteration 8: 100%|██████████| 50/50 [01:33<00:00,  1.88s/it, episode=450,\n",
    "# return=193.800]\n",
    "# Iteration 9: 100%|██████████| 50/50 [01:34<00:00,  1.88s/it, episode=500,\n",
    "# return=200.000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 573
    },
    "executionInfo": {
     "elapsed": 698,
     "status": "ok",
     "timestamp": 1649955495697,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "AFiCxG4W-xIy",
    "outputId": "b5610f6f-8df9-4156-ecb9-e8cb2901133c"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#https://github.com/guicalare/Img2gif/blob/master/Code/Img2Gif.py\n",
    "imageio.mimsave(r'C:\\Users\\10696\\Desktop\\access\\Hands-on-RL\\chapter7.gif', allimage, duration=10)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('DQN on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('DQN on {}'.format(env_name))\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./chapter7.gif\" width=\"30%\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "CDk1DgrL-xIz"
   },
   "outputs": [],
   "source": [
    "class ConvolutionalQnet(torch.nn.Module):\n",
    "    ''' 加入卷积层的Q网络 '''\n",
    "    def __init__(self, action_dim, in_channels=4):\n",
    "        super(ConvolutionalQnet, self).__init__()\n",
    "        self.conv1 = torch.nn.Conv2d(in_channels, 32, kernel_size=8, stride=4)\n",
    "        self.conv2 = torch.nn.Conv2d(32, 64, kernel_size=4, stride=2)\n",
    "        self.conv3 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1)\n",
    "        self.fc4 = torch.nn.Linear(7 * 7 * 64, 512)\n",
    "        self.head = torch.nn.Linear(512, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x / 255\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = F.relu(self.fc4(x))\n",
    "        return self.head(x)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "第7章-DQN算法.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
